home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / MacMemory.a < prev    next >
Encoding:
Text File  |  1998-02-12  |  35.2 KB  |  1,481 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        MacMemory.a
  3. ;
  4. ;    Contains:    Memory Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.1
  8. ;
  9. ;    Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__MACMEMORY__') = 'UNDEFINED' THEN
  19. __MACMEMORY__ SET 1
  20.  
  21.  
  22.     IF &TYPE('__MACTYPES__') = 'UNDEFINED' THEN
  23.     include 'MacTypes.a'
  24.     ENDIF
  25.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  26.     include 'MixedMode.a'
  27.     ENDIF
  28.  
  29.  
  30.  
  31. maxSize                            EQU        $00800000            ;Max data block size is 8 megabytes
  32.  
  33. defaultPhysicalEntryCount        EQU        8
  34.  
  35.                                                             ; values returned from the GetPageState function 
  36. kPageInMemory                    EQU        0
  37. kPageOnDisk                        EQU        1
  38. kNotPaged                        EQU        2
  39.  
  40.                                                             ; masks for Zone->heapType field 
  41. k32BitHeap                        EQU        1                    ; valid in all Memory Managers 
  42. kNewStyleHeap                    EQU        2                    ; true if new Heap Manager is present 
  43. kNewDebugHeap                    EQU        4                    ; true if new Heap Manager is running in debug mode on this heap 
  44. ;  Note: The type "Size" moved to Types.h 
  45.  
  46.  
  47. Zone                    RECORD 0
  48. bkLim                     ds.l    1                ; offset: $0 (0)
  49. purgePtr                 ds.l    1                ; offset: $4 (4)
  50. hFstFree                 ds.l    1                ; offset: $8 (8)
  51. zcbFree                     ds.l    1                ; offset: $C (12)
  52. gzProc                     ds.l    1                ; offset: $10 (16)
  53. moreMast                 ds.w    1                ; offset: $14 (20)
  54. flags                     ds.w    1                ; offset: $16 (22)
  55. cntRel                     ds.w    1                ; offset: $18 (24)
  56. maxRel                     ds.w    1                ; offset: $1A (26)
  57. cntNRel                     ds.w    1                ; offset: $1C (28)
  58. heapType                 ds.b    1                ; offset: $1E (30)        ;  previously "maxNRel", now holds flags (e.g. k32BitHeap)
  59. unused                     ds.b    1                ; offset: $1F (31)
  60. cntEmpty                 ds.w    1                ; offset: $20 (32)
  61. cntHandles                 ds.w    1                ; offset: $22 (34)
  62. minCBFree                 ds.l    1                ; offset: $24 (36)
  63. purgeProc                 ds.l    1                ; offset: $28 (40)
  64. sparePtr                 ds.l    1                ; offset: $2C (44)
  65. allocPtr                 ds.l    1                ; offset: $30 (48)
  66. heapData                 ds.w    1                ; offset: $34 (52)
  67. sizeof                     EQU *                    ; size:   $36 (54)
  68.                         ENDR
  69. ; typedef struct Zone *                    THz
  70.  
  71. MemoryBlock                RECORD 0
  72. address                     ds.l    1                ; offset: $0 (0)
  73. count                     ds.l    1                ; offset: $4 (4)
  74. sizeof                     EQU *                    ; size:   $8 (8)
  75.                         ENDR
  76. LogicalToPhysicalTable    RECORD 0
  77. logical                     ds        MemoryBlock        ; offset: $0 (0)
  78. physical                 ds.b    8 * MemoryBlock.sizeof ; offset: $8 (8)
  79. sizeof                     EQU *                    ; size:   $48 (72)
  80.                         ENDR
  81. ; typedef short                         PageState
  82.  
  83. ; typedef short                         StatusRegisterContents
  84.  
  85.  
  86.  
  87. ;
  88. ; pascal Ptr GetApplLimit(void)
  89. ;
  90.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  91.         Macro
  92.         _GetApplLimit         &dest=(sp)
  93.             move.l            $0130,&dest
  94.         EndM
  95.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  96.         IMPORT_CFM_FUNCTION GetApplLimit
  97.     ENDIF
  98.  
  99. ;
  100. ; pascal THz SystemZone(void)
  101. ;
  102.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  103.         Macro
  104.         _SystemZone           &dest=(sp)
  105.             move.l            $02A6,&dest
  106.         EndM
  107.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  108.         IMPORT_CFM_FUNCTION SystemZone
  109.     ENDIF
  110.  
  111. ;
  112. ; pascal THz ApplicationZone(void)
  113. ;
  114.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  115.         Macro
  116.         _ApplicationZone      &dest=(sp)
  117.             move.l            $02AA,&dest
  118.         EndM
  119.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  120.         IMPORT_CFM_FUNCTION ApplicationZone
  121.     ENDIF
  122.  
  123. ;
  124. ; pascal Handle GZSaveHnd(void)
  125. ;
  126.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  127.         Macro
  128.         _GZSaveHnd            &dest=(sp)
  129.             move.l            $0328,&dest
  130.         EndM
  131.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  132.         IMPORT_CFM_FUNCTION GZSaveHnd
  133.     ENDIF
  134.  
  135. ;
  136. ; pascal Ptr TopMem(void)
  137. ;
  138.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  139.         Macro
  140.         _TopMem               &dest=(sp)
  141.             move.l            $0108,&dest
  142.         EndM
  143.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  144.         IMPORT_CFM_FUNCTION TopMem
  145.     ENDIF
  146.  
  147. ;
  148. ; pascal OSErr MemError(void)
  149. ;
  150.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  151.         Macro
  152.         _MemError             &dest=(sp)
  153.             move.w            $0220,&dest
  154.         EndM
  155.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  156.         IMPORT_CFM_FUNCTION MemError
  157.     ENDIF
  158.  
  159.  
  160.  
  161. ;
  162. ; pascal THz GetZone(void )
  163. ;
  164.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  165.         ; returns:
  166.         ;    THz             <= A0
  167.         _GetZone:    OPWORD    $A11A
  168.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  169.         IMPORT_CFM_FUNCTION GetZone
  170.     ENDIF
  171.  
  172. ;
  173. ; pascal Handle NewHandle(Size byteCount)
  174. ;
  175.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  176.         ; parameters:
  177.         ;    byteCount       => D0
  178.         ; returns:
  179.         ;    Handle          <= A0
  180.         _NewHandle:    OPWORD    $A122
  181.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  182.         IMPORT_CFM_FUNCTION NewHandle
  183.     ENDIF
  184.  
  185. ;
  186. ; pascal Handle NewHandleSys(Size byteCount)
  187. ;
  188.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  189.         ; parameters:
  190.         ;    byteCount       => D0
  191.         ; returns:
  192.         ;    Handle          <= A0
  193.         _NewHandleSys:    OPWORD    $A522
  194.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  195.         IMPORT_CFM_FUNCTION NewHandleSys
  196.     ENDIF
  197.  
  198. ;
  199. ; pascal Handle NewHandleClear(Size byteCount)
  200. ;
  201.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  202.         ; parameters:
  203.         ;    byteCount       => D0
  204.         ; returns:
  205.         ;    Handle          <= A0
  206.         _NewHandleClear:    OPWORD    $A322
  207.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  208.         IMPORT_CFM_FUNCTION NewHandleClear
  209.     ENDIF
  210.  
  211. ;
  212. ; pascal Handle NewHandleSysClear(Size byteCount)
  213. ;
  214.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  215.         ; parameters:
  216.         ;    byteCount       => D0
  217.         ; returns:
  218.         ;    Handle          <= A0
  219.         _NewHandleSysClear:    OPWORD    $A722
  220.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  221.         IMPORT_CFM_FUNCTION NewHandleSysClear
  222.     ENDIF
  223.  
  224. ;
  225. ; pascal THz HandleZone(Handle h)
  226. ;
  227.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  228.         ; parameters:
  229.         ;    h               => A0
  230.         ; returns:
  231.         ;    THz             <= A0
  232.         _HandleZone:    OPWORD    $A126
  233.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  234.         IMPORT_CFM_FUNCTION HandleZone
  235.     ENDIF
  236.  
  237. ;
  238. ; pascal Handle RecoverHandle(Ptr p)
  239. ;
  240.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  241.         ; parameters:
  242.         ;    p               => A0
  243.         ; returns:
  244.         ;    Handle          <= A0
  245.         _RecoverHandle:    OPWORD    $A128
  246.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  247.         IMPORT_CFM_FUNCTION RecoverHandle
  248.     ENDIF
  249.  
  250. ;
  251. ; pascal Handle RecoverHandleSys(Ptr p)
  252. ;
  253.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  254.         ; parameters:
  255.         ;    p               => A0
  256.         ; returns:
  257.         ;    Handle          <= A0
  258.         _RecoverHandleSys:    OPWORD    $A528
  259.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  260.         IMPORT_CFM_FUNCTION RecoverHandleSys
  261.     ENDIF
  262.  
  263. ;
  264. ; pascal Ptr NewPtr(Size byteCount)
  265. ;
  266.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  267.         ; parameters:
  268.         ;    byteCount       => D0
  269.         ; returns:
  270.         ;    Ptr             <= A0
  271.         _NewPtr:    OPWORD    $A11E
  272.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  273.         IMPORT_CFM_FUNCTION NewPtr
  274.     ENDIF
  275.  
  276. ;
  277. ; pascal Ptr NewPtrSys(Size byteCount)
  278. ;
  279.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  280.         ; parameters:
  281.         ;    byteCount       => D0
  282.         ; returns:
  283.         ;    Ptr             <= A0
  284.         _NewPtrSys:    OPWORD    $A51E
  285.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  286.         IMPORT_CFM_FUNCTION NewPtrSys
  287.     ENDIF
  288.  
  289. ;
  290. ; pascal Ptr NewPtrClear(Size byteCount)
  291. ;
  292.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  293.         ; parameters:
  294.         ;    byteCount       => D0
  295.         ; returns:
  296.         ;    Ptr             <= A0
  297.         _NewPtrClear:    OPWORD    $A31E
  298.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  299.         IMPORT_CFM_FUNCTION NewPtrClear
  300.     ENDIF
  301.  
  302. ;
  303. ; pascal Ptr NewPtrSysClear(Size byteCount)
  304. ;
  305.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  306.         ; parameters:
  307.         ;    byteCount       => D0
  308.         ; returns:
  309.         ;    Ptr             <= A0
  310.         _NewPtrSysClear:    OPWORD    $A71E
  311.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  312.         IMPORT_CFM_FUNCTION NewPtrSysClear
  313.     ENDIF
  314.  
  315. ;
  316. ; pascal THz PtrZone(Ptr p)
  317. ;
  318.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  319.         ; parameters:
  320.         ;    p               => A0
  321.         ; returns:
  322.         ;    THz             <= A0
  323.         _PtrZone:    OPWORD    $A148
  324.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  325.         IMPORT_CFM_FUNCTION PtrZone
  326.     ENDIF
  327.  
  328. ;
  329. ; pascal long MaxBlock(void )
  330. ;
  331.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  332.         ; returns:
  333.         ;    long            <= D0
  334.         _MaxBlock:    OPWORD    $A061
  335.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  336.         IMPORT_CFM_FUNCTION MaxBlock
  337.     ENDIF
  338.  
  339. ;
  340. ; pascal long MaxBlockSys(void )
  341. ;
  342.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  343.         ; returns:
  344.         ;    long            <= D0
  345.         _MaxBlockSys:    OPWORD    $A461
  346.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  347.         IMPORT_CFM_FUNCTION MaxBlockSys
  348.     ENDIF
  349.  
  350. ;
  351. ; pascal long StackSpace(void )
  352. ;
  353.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  354.         ; returns:
  355.         ;    long            <= D0
  356.         _StackSpace:    OPWORD    $A065
  357.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  358.         IMPORT_CFM_FUNCTION StackSpace
  359.     ENDIF
  360.  
  361. ;
  362. ; pascal Handle NewEmptyHandle(void )
  363. ;
  364.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  365.         ; returns:
  366.         ;    Handle          <= A0
  367.         _NewEmptyHandle:    OPWORD    $A166
  368.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  369.         IMPORT_CFM_FUNCTION NewEmptyHandle
  370.     ENDIF
  371.  
  372. ;
  373. ; pascal Handle NewEmptyHandleSys(void )
  374. ;
  375.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  376.         ; returns:
  377.         ;    Handle          <= A0
  378.         _NewEmptyHandleSys:    OPWORD    $A566
  379.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  380.         IMPORT_CFM_FUNCTION NewEmptyHandleSys
  381.     ENDIF
  382.  
  383. ;
  384. ; pascal void HLock(Handle h)
  385. ;
  386.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  387.         ; parameters:
  388.         ;    h               => A0
  389.         _HLock:    OPWORD    $A029
  390.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  391.         IMPORT_CFM_FUNCTION HLock
  392.     ENDIF
  393.  
  394. ;
  395. ; pascal void HUnlock(Handle h)
  396. ;
  397.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  398.         ; parameters:
  399.         ;    h               => A0
  400.         _HUnlock:    OPWORD    $A02A
  401.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  402.         IMPORT_CFM_FUNCTION HUnlock
  403.     ENDIF
  404.  
  405. ;
  406. ; pascal void HPurge(Handle h)
  407. ;
  408.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  409.         ; parameters:
  410.         ;    h               => A0
  411.         _HPurge:    OPWORD    $A049
  412.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  413.         IMPORT_CFM_FUNCTION HPurge
  414.     ENDIF
  415.  
  416. ;
  417. ; pascal void HNoPurge(Handle h)
  418. ;
  419.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  420.         ; parameters:
  421.         ;    h               => A0
  422.         _HNoPurge:    OPWORD    $A04A
  423.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  424.         IMPORT_CFM_FUNCTION HNoPurge
  425.     ENDIF
  426.  
  427. ;
  428. ; pascal void HLockHi(Handle h)
  429. ;
  430.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  431.         ; parameters:
  432.         ;    h               => A0
  433.         Macro
  434.         _HLockHi
  435.             dc.w                $A064
  436.             dc.w                $A029
  437.         EndM
  438.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  439.         IMPORT_CFM_FUNCTION HLockHi
  440.     ENDIF
  441.  
  442. ;
  443. ; pascal Handle TempNewHandle(Size logicalSize, OSErr *resultCode)
  444. ;
  445.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  446.         Macro
  447.         _TempNewHandle
  448.             move.w              #$001D,-(sp)
  449.             dc.w                $A88F
  450.         EndM
  451.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  452.         IMPORT_CFM_FUNCTION TempNewHandle
  453.     ENDIF
  454.  
  455. ;
  456. ; pascal Size TempMaxMem(Size *grow)
  457. ;
  458.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  459.         Macro
  460.         _TempMaxMem
  461.             move.w              #$0015,-(sp)
  462.             dc.w                $A88F
  463.         EndM
  464.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  465.         IMPORT_CFM_FUNCTION TempMaxMem
  466.     ENDIF
  467.  
  468. ;
  469. ; pascal long TempFreeMem(void )
  470. ;
  471.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  472.         Macro
  473.         _TempFreeMem
  474.             move.w              #$0018,-(sp)
  475.             dc.w                $A88F
  476.         EndM
  477.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  478.         IMPORT_CFM_FUNCTION TempFreeMem
  479.     ENDIF
  480.  
  481. ;
  482. ; pascal void InitZone(GrowZoneUPP pgrowZone, short cmoreMasters, void *limitPtr, void *startPtr)
  483. ;
  484.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  485.         _InitZone:    OPWORD    $A019
  486.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  487.         IMPORT_CFM_FUNCTION InitZone
  488.     ENDIF
  489.  
  490. ;
  491. ; pascal void SetZone(THz hz)
  492. ;
  493.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  494.         ; parameters:
  495.         ;    hz              => A0
  496.         _SetZone:    OPWORD    $A01B
  497.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  498.         IMPORT_CFM_FUNCTION SetZone
  499.     ENDIF
  500.  
  501. ;
  502. ; pascal Size CompactMem(Size cbNeeded)
  503. ;
  504.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  505.         ; parameters:
  506.         ;    cbNeeded        => D0
  507.         ; returns:
  508.         ;    Size            <= D0
  509.         _CompactMem:    OPWORD    $A04C
  510.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  511.         IMPORT_CFM_FUNCTION CompactMem
  512.     ENDIF
  513.  
  514. ;
  515. ; pascal Size CompactMemSys(Size cbNeeded)
  516. ;
  517.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  518.         ; parameters:
  519.         ;    cbNeeded        => D0
  520.         ; returns:
  521.         ;    Size            <= D0
  522.         _CompactMemSys:    OPWORD    $A44C
  523.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  524.         IMPORT_CFM_FUNCTION CompactMemSys
  525.     ENDIF
  526.  
  527. ;
  528. ; pascal void PurgeMem(Size cbNeeded)
  529. ;
  530.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  531.         ; parameters:
  532.         ;    cbNeeded        => D0
  533.         _PurgeMem:    OPWORD    $A04D
  534.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  535.         IMPORT_CFM_FUNCTION PurgeMem
  536.     ENDIF
  537.  
  538. ;
  539. ; pascal void PurgeMemSys(Size cbNeeded)
  540. ;
  541.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  542.         ; parameters:
  543.         ;    cbNeeded        => D0
  544.         _PurgeMemSys:    OPWORD    $A44D
  545.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  546.         IMPORT_CFM_FUNCTION PurgeMemSys
  547.     ENDIF
  548.  
  549. ;
  550. ; pascal long FreeMem(void )
  551. ;
  552.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  553.         ; returns:
  554.         ;    long            <= D0
  555.         _FreeMem:    OPWORD    $A01C
  556.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  557.         IMPORT_CFM_FUNCTION FreeMem
  558.     ENDIF
  559.  
  560. ;
  561. ; pascal long FreeMemSys(void )
  562. ;
  563.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  564.         ; returns:
  565.         ;    long            <= D0
  566.         _FreeMemSys:    OPWORD    $A41C
  567.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  568.         IMPORT_CFM_FUNCTION FreeMemSys
  569.     ENDIF
  570.  
  571. ;
  572. ; pascal void ReserveMem(Size cbNeeded)
  573. ;
  574.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  575.         ; parameters:
  576.         ;    cbNeeded        => D0
  577.         _ReserveMem:    OPWORD    $A040
  578.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  579.         IMPORT_CFM_FUNCTION ReserveMem
  580.     ENDIF
  581.  
  582. ;
  583. ; pascal void ReserveMemSys(Size cbNeeded)
  584. ;
  585.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  586.         ; parameters:
  587.         ;    cbNeeded        => D0
  588.         _ReserveMemSys:    OPWORD    $A440
  589.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  590.         IMPORT_CFM_FUNCTION ReserveMemSys
  591.     ENDIF
  592.  
  593. ;
  594. ; pascal Size MaxMem(Size *grow)
  595. ;
  596.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  597.         _MaxMem:    OPWORD    $A11D
  598.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  599.         IMPORT_CFM_FUNCTION MaxMem
  600.     ENDIF
  601.  
  602. ;
  603. ; pascal Size MaxMemSys(Size *grow)
  604. ;
  605.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  606.         _MaxMemSys:    OPWORD    $A51D
  607.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  608.         IMPORT_CFM_FUNCTION MaxMemSys
  609.     ENDIF
  610.  
  611. ;
  612. ; pascal void SetGrowZone(GrowZoneUPP growZone)
  613. ;
  614.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  615.         ; parameters:
  616.         ;    growZone        => A0
  617.         _SetGrowZone:    OPWORD    $A04B
  618.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  619.         IMPORT_CFM_FUNCTION SetGrowZone
  620.     ENDIF
  621.  
  622. ;
  623. ; pascal void MoveHHi(Handle h)
  624. ;
  625.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  626.         ; parameters:
  627.         ;    h               => A0
  628.         _MoveHHi:    OPWORD    $A064
  629.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  630.         IMPORT_CFM_FUNCTION MoveHHi
  631.     ENDIF
  632.  
  633. ;
  634. ; pascal void DisposePtr(Ptr p)
  635. ;
  636.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  637.         ; parameters:
  638.         ;    p               => A0
  639.         _DisposePtr:    OPWORD    $A01F
  640.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  641.         IMPORT_CFM_FUNCTION DisposePtr
  642.     ENDIF
  643.  
  644. ;
  645. ; pascal Size GetPtrSize(Ptr p)
  646. ;
  647.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  648.         _GetPtrSize:    OPWORD    $A021
  649.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  650.         IMPORT_CFM_FUNCTION GetPtrSize
  651.     ENDIF
  652.  
  653. ;
  654. ; pascal void SetPtrSize(Ptr p, Size newSize)
  655. ;
  656.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  657.         ; parameters:
  658.         ;    p               => A0
  659.         ;    newSize         => D0
  660.         _SetPtrSize:    OPWORD    $A020
  661.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  662.         IMPORT_CFM_FUNCTION SetPtrSize
  663.     ENDIF
  664.  
  665. ;
  666. ; pascal void DisposeHandle(Handle h)
  667. ;
  668.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  669.         ; parameters:
  670.         ;    h               => A0
  671.         _DisposeHandle:    OPWORD    $A023
  672.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  673.         IMPORT_CFM_FUNCTION DisposeHandle
  674.     ENDIF
  675.  
  676. ;
  677. ; pascal void SetHandleSize(Handle h, Size newSize)
  678. ;
  679.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  680.         ; parameters:
  681.         ;    h               => A0
  682.         ;    newSize         => D0
  683.         _SetHandleSize:    OPWORD    $A024
  684.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  685.         IMPORT_CFM_FUNCTION SetHandleSize
  686.     ENDIF
  687.  
  688. ;  
  689. ;    NOTE
  690. ;    
  691. ;    GetHandleSize and GetPtrSize are documented in Inside Mac as returning 0 
  692. ;    in case of an error, but the traps actually return an error code in D0.
  693. ;    The glue sets D0 to 0 if an error occured.
  694. ;
  695.  
  696. ;
  697. ; pascal Size GetHandleSize(Handle h)
  698. ;
  699.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  700.         _GetHandleSize:    OPWORD    $A025
  701.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  702.         IMPORT_CFM_FUNCTION GetHandleSize
  703.     ENDIF
  704.  
  705. ;
  706. ; pascal Size InlineGetHandleSize(Handle h)
  707. ;
  708.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  709.         ; parameters:
  710.         ;    h               => A0
  711.         ; returns:
  712.         ;    Size            <= D0
  713.         _InlineGetHandleSize:    OPWORD    $A025
  714.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  715.         IMPORT_CFM_FUNCTION InlineGetHandleSize
  716.     ENDIF
  717.  
  718. ;
  719. ; pascal void ReallocateHandle(Handle h, Size byteCount)
  720. ;
  721.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  722.         ; parameters:
  723.         ;    h               => A0
  724.         ;    byteCount       => D0
  725.         _ReallocateHandle:    OPWORD    $A027
  726.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  727.         IMPORT_CFM_FUNCTION ReallocateHandle
  728.     ENDIF
  729.  
  730. ;
  731. ; pascal void ReallocateHandleSys(Handle h, Size byteCount)
  732. ;
  733.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  734.         ; parameters:
  735.         ;    h               => A0
  736.         ;    byteCount       => D0
  737.         _ReallocateHandleSys:    OPWORD    $A427
  738.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  739.         IMPORT_CFM_FUNCTION ReallocateHandleSys
  740.     ENDIF
  741.  
  742. ;
  743. ; pascal void EmptyHandle(Handle h)
  744. ;
  745.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  746.         ; parameters:
  747.         ;    h               => A0
  748.         _EmptyHandle:    OPWORD    $A02B
  749.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  750.         IMPORT_CFM_FUNCTION EmptyHandle
  751.     ENDIF
  752.  
  753. ;
  754. ; pascal void HSetRBit(Handle h)
  755. ;
  756.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  757.         ; parameters:
  758.         ;    h               => A0
  759.         _HSetRBit:    OPWORD    $A067
  760.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  761.         IMPORT_CFM_FUNCTION HSetRBit
  762.     ENDIF
  763.  
  764. ;
  765. ; pascal void HClrRBit(Handle h)
  766. ;
  767.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  768.         ; parameters:
  769.         ;    h               => A0
  770.         _HClrRBit:    OPWORD    $A068
  771.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  772.         IMPORT_CFM_FUNCTION HClrRBit
  773.     ENDIF
  774.  
  775. ;
  776. ; pascal SInt8 HGetState(Handle h)
  777. ;
  778.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  779.         ; parameters:
  780.         ;    h               => A0
  781.         ; returns:
  782.         ;    SInt8           <= D0
  783.         _HGetState:    OPWORD    $A069
  784.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  785.         IMPORT_CFM_FUNCTION HGetState
  786.     ENDIF
  787.  
  788. ;
  789. ; pascal void HSetState(Handle h, SInt8 flags)
  790. ;
  791.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  792.         ; parameters:
  793.         ;    h               => A0
  794.         ;    flags           => D0
  795.         _HSetState:    OPWORD    $A06A
  796.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  797.         IMPORT_CFM_FUNCTION HSetState
  798.     ENDIF
  799.  
  800. ;
  801. ; pascal void PurgeSpace(long *total, long *contig)
  802. ;
  803.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  804.         _PurgeSpace:    OPWORD    $A162
  805.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  806.         IMPORT_CFM_FUNCTION PurgeSpace
  807.     ENDIF
  808.  
  809.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  810. ; 
  811. ;    PurgeSpaceTotal and PurgeSpaceContiguous are currently only implement
  812. ;    on classic 68K.  The are the same as PurgeSpace() but return just
  813. ;    one value (either total space purgable or contiguous space purgable).
  814. ;
  815.  
  816. ;
  817. ; pascal long PurgeSpaceTotal(void )
  818. ;
  819.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  820.         ; returns:
  821.         ;    long            <= A0
  822.         _PurgeSpaceTotal:    OPWORD    $A062
  823.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  824.         IMPORT_CFM_FUNCTION PurgeSpaceTotal
  825.     ENDIF
  826.  
  827. ;
  828. ; pascal long PurgeSpaceContiguous(void )
  829. ;
  830.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  831.         ; returns:
  832.         ;    long            <= D0
  833.         _PurgeSpaceContiguous:    OPWORD    $A062
  834.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  835.         IMPORT_CFM_FUNCTION PurgeSpaceContiguous
  836.     ENDIF
  837.  
  838. ;
  839. ; pascal long PurgeSpaceSysTotal(void )
  840. ;
  841.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  842.         ; returns:
  843.         ;    long            <= A0
  844.         _PurgeSpaceSysTotal:    OPWORD    $A562
  845.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  846.         IMPORT_CFM_FUNCTION PurgeSpaceSysTotal
  847.     ENDIF
  848.  
  849. ;
  850. ; pascal long PurgeSpaceSysContiguous(void )
  851. ;
  852.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  853.         ; returns:
  854.         ;    long            <= D0
  855.         _PurgeSpaceSysContiguous:    OPWORD    $A562
  856.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  857.         IMPORT_CFM_FUNCTION PurgeSpaceSysContiguous
  858.     ENDIF
  859.  
  860.     ENDIF
  861. ; *****************************************************************************
  862. ;
  863. ;    The routines: 
  864. ;
  865. ;        BlockMoveUncached
  866. ;        BlockMoveDataUncached
  867. ;        BlockZero
  868. ;        BlockZeroUncached
  869. ;    
  870. ;    are intended for developers writing drivers. They do not exist in 
  871. ;    “InterfaceLib.” You must link with “DriverServicesLib” to access them.
  872. ;    
  873. ;    But since BlockMove and BlockMoveData exist in both “InterfaceLib” and
  874. ;    “DriverServicesLib”, you cannot link with both libraries.
  875. ;    
  876. ;****************************************************************************
  877.  
  878. ;
  879. ; pascal void BlockMove(const void *srcPtr, void *destPtr, Size byteCount)
  880. ;
  881.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  882.         ; parameters:
  883.         ;    srcPtr          => A0
  884.         ;    destPtr         => A1
  885.         ;    byteCount       => D0
  886.         _BlockMove:    OPWORD    $A02E
  887.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  888.         IMPORT_CFM_FUNCTION BlockMove
  889.     ENDIF
  890.  
  891. ;
  892. ; pascal void BlockMoveData(const void *srcPtr, void *destPtr, Size byteCount)
  893. ;
  894.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  895.         ; parameters:
  896.         ;    srcPtr          => A0
  897.         ;    destPtr         => A1
  898.         ;    byteCount       => D0
  899.         _BlockMoveData:    OPWORD    $A22E
  900.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  901.         IMPORT_CFM_FUNCTION BlockMoveData
  902.     ENDIF
  903.  
  904. ;
  905. ; extern void BlockMoveUncached(const void *srcPtr, void *destPtr, Size byteCount)
  906. ;
  907.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  908.         IMPORT_CFM_FUNCTION BlockMoveUncached
  909.     ENDIF
  910.  
  911. ;
  912. ; extern void BlockMoveDataUncached(const void *srcPtr, void *destPtr, Size byteCount)
  913. ;
  914.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  915.         IMPORT_CFM_FUNCTION BlockMoveDataUncached
  916.     ENDIF
  917.  
  918. ;
  919. ; extern void BlockZero(void *destPtr, Size byteCount)
  920. ;
  921.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  922.         IMPORT_CFM_FUNCTION BlockZero
  923.     ENDIF
  924.  
  925. ;
  926. ; extern void BlockZeroUncached(void *destPtr, Size byteCount)
  927. ;
  928.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  929.         IMPORT_CFM_FUNCTION BlockZeroUncached
  930.     ENDIF
  931.  
  932.  
  933. ;
  934. ; pascal void MaxApplZone(void )
  935. ;
  936.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  937.         _MaxApplZone:    OPWORD    $A063
  938.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  939.         IMPORT_CFM_FUNCTION MaxApplZone
  940.     ENDIF
  941.  
  942. ;
  943. ; pascal void SetApplBase(void *startPtr)
  944. ;
  945.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  946.         ; parameters:
  947.         ;    startPtr        => A0
  948.         _SetApplBase:    OPWORD    $A057
  949.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  950.         IMPORT_CFM_FUNCTION SetApplBase
  951.     ENDIF
  952.  
  953. ;
  954. ; pascal void MoreMasters(void )
  955. ;
  956.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  957.         _MoreMasters:    OPWORD    $A036
  958.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  959.         IMPORT_CFM_FUNCTION MoreMasters
  960.     ENDIF
  961.  
  962. ;
  963. ; pascal void SetApplLimit(void *zoneLimit)
  964. ;
  965.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  966.         ; parameters:
  967.         ;    zoneLimit       => A0
  968.         _SetApplLimit:    OPWORD    $A02D
  969.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  970.         IMPORT_CFM_FUNCTION SetApplLimit
  971.     ENDIF
  972.  
  973.  
  974.  
  975. ;
  976. ; pascal void InitApplZone(void )
  977. ;
  978.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  979.         _InitApplZone:    OPWORD    $A02C
  980.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  981.         IMPORT_CFM_FUNCTION InitApplZone
  982.     ENDIF
  983.  
  984.  
  985. ;   Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  
  986. ;
  987. ; pascal void TempHLock(Handle h, OSErr *resultCode)
  988. ;
  989.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  990.         Macro
  991.         _TempHLock
  992.             move.w              #$001E,-(sp)
  993.             dc.w                $A88F
  994.         EndM
  995.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  996.         IMPORT_CFM_FUNCTION TempHLock
  997.     ENDIF
  998.  
  999. ;
  1000. ; pascal void TempHUnlock(Handle h, OSErr *resultCode)
  1001. ;
  1002.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1003.         Macro
  1004.         _TempHUnlock
  1005.             move.w              #$001F,-(sp)
  1006.             dc.w                $A88F
  1007.         EndM
  1008.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1009.         IMPORT_CFM_FUNCTION TempHUnlock
  1010.     ENDIF
  1011.  
  1012. ;
  1013. ; pascal void TempDisposeHandle(Handle h, OSErr *resultCode)
  1014. ;
  1015.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1016.         Macro
  1017.         _TempDisposeHandle
  1018.             move.w              #$0020,-(sp)
  1019.             dc.w                $A88F
  1020.         EndM
  1021.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1022.         IMPORT_CFM_FUNCTION TempDisposeHandle
  1023.     ENDIF
  1024.  
  1025. ;
  1026. ; pascal Ptr TempTopMem(void )
  1027. ;
  1028.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1029.         Macro
  1030.         _TempTopMem
  1031.             move.w              #$0016,-(sp)
  1032.             dc.w                $A88F
  1033.         EndM
  1034.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1035.         IMPORT_CFM_FUNCTION TempTopMem
  1036.     ENDIF
  1037.  
  1038. ;
  1039. ; pascal OSErr HoldMemory(void *address, unsigned long count)
  1040. ;
  1041.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1042.         ; parameters:
  1043.         ;    address         => A0
  1044.         ;    count           => A1
  1045.         ; returns:
  1046.         ;    OSErr           <= D0
  1047.         Macro
  1048.         _HoldMemory
  1049.             moveq               #0,D0
  1050.             dc.w                $A05C
  1051.         EndM
  1052.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1053.         IMPORT_CFM_FUNCTION HoldMemory
  1054.     ENDIF
  1055.  
  1056. ;
  1057. ; pascal OSErr UnholdMemory(void *address, unsigned long count)
  1058. ;
  1059.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1060.         ; parameters:
  1061.         ;    address         => A0
  1062.         ;    count           => A1
  1063.         ; returns:
  1064.         ;    OSErr           <= D0
  1065.         Macro
  1066.         _UnholdMemory
  1067.             moveq               #1,D0
  1068.             dc.w                $A05C
  1069.         EndM
  1070.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1071.         IMPORT_CFM_FUNCTION UnholdMemory
  1072.     ENDIF
  1073.  
  1074. ;
  1075. ; pascal OSErr LockMemory(void *address, unsigned long count)
  1076. ;
  1077.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1078.         ; parameters:
  1079.         ;    address         => A0
  1080.         ;    count           => A1
  1081.         ; returns:
  1082.         ;    OSErr           <= D0
  1083.         Macro
  1084.         _LockMemory
  1085.             moveq               #2,D0
  1086.             dc.w                $A05C
  1087.         EndM
  1088.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1089.         IMPORT_CFM_FUNCTION LockMemory
  1090.     ENDIF
  1091.  
  1092. ;
  1093. ; pascal OSErr LockMemoryForOutput(void *address, unsigned long count)
  1094. ;
  1095.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1096.         ; parameters:
  1097.         ;    address         => A0
  1098.         ;    count           => A1
  1099.         ; returns:
  1100.         ;    OSErr           <= D0
  1101.         Macro
  1102.         _LockMemoryForOutput
  1103.             moveq               #10,D0
  1104.             dc.w                $A05C
  1105.         EndM
  1106.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1107.         IMPORT_CFM_FUNCTION LockMemoryForOutput
  1108.     ENDIF
  1109.  
  1110. ;
  1111. ; pascal OSErr LockMemoryContiguous(void *address, unsigned long count)
  1112. ;
  1113.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1114.         ; parameters:
  1115.         ;    address         => A0
  1116.         ;    count           => A1
  1117.         ; returns:
  1118.         ;    OSErr           <= D0
  1119.         Macro
  1120.         _LockMemoryContiguous
  1121.             moveq               #4,D0
  1122.             dc.w                $A05C
  1123.         EndM
  1124.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1125.         IMPORT_CFM_FUNCTION LockMemoryContiguous
  1126.     ENDIF
  1127.  
  1128. ;
  1129. ; pascal OSErr UnlockMemory(void *address, unsigned long count)
  1130. ;
  1131.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1132.         ; parameters:
  1133.         ;    address         => A0
  1134.         ;    count           => A1
  1135.         ; returns:
  1136.         ;    OSErr           <= D0
  1137.         Macro
  1138.         _UnlockMemory
  1139.             moveq               #3,D0
  1140.             dc.w                $A05C
  1141.         EndM
  1142.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1143.         IMPORT_CFM_FUNCTION UnlockMemory
  1144.     ENDIF
  1145.  
  1146. ;
  1147. ; pascal OSErr MakeMemoryResident(void *address, unsigned long count)
  1148. ;
  1149.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1150.         ; parameters:
  1151.         ;    address         => A0
  1152.         ;    count           => A1
  1153.         ; returns:
  1154.         ;    OSErr           <= D0
  1155.         Macro
  1156.         _MakeMemoryResident
  1157.             moveq               #11,D0
  1158.             dc.w                $A05C
  1159.         EndM
  1160.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1161.         IMPORT_CFM_FUNCTION MakeMemoryResident
  1162.     ENDIF
  1163.  
  1164. ;
  1165. ; pascal OSErr ReleaseMemoryData(void *address, unsigned long count)
  1166. ;
  1167.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1168.         ; parameters:
  1169.         ;    address         => A0
  1170.         ;    count           => A1
  1171.         ; returns:
  1172.         ;    OSErr           <= D0
  1173.         Macro
  1174.         _ReleaseMemoryData
  1175.             moveq               #12,D0
  1176.             dc.w                $A05C
  1177.         EndM
  1178.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1179.         IMPORT_CFM_FUNCTION ReleaseMemoryData
  1180.     ENDIF
  1181.  
  1182. ;
  1183. ; pascal OSErr MakeMemoryNonResident(void *address, unsigned long count)
  1184. ;
  1185.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1186.         ; parameters:
  1187.         ;    address         => A0
  1188.         ;    count           => A1
  1189.         ; returns:
  1190.         ;    OSErr           <= D0
  1191.         Macro
  1192.         _MakeMemoryNonResident
  1193.             moveq               #13,D0
  1194.             dc.w                $A05C
  1195.         EndM
  1196.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1197.         IMPORT_CFM_FUNCTION MakeMemoryNonResident
  1198.     ENDIF
  1199.  
  1200. ;
  1201. ; pascal OSErr FlushMemory(void *address, unsigned long count)
  1202. ;
  1203.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1204.         ; parameters:
  1205.         ;    address         => A0
  1206.         ;    count           => A1
  1207.         ; returns:
  1208.         ;    OSErr           <= D0
  1209.         Macro
  1210.         _FlushMemory
  1211.             moveq               #14,D0
  1212.             dc.w                $A05C
  1213.         EndM
  1214.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1215.         IMPORT_CFM_FUNCTION FlushMemory
  1216.     ENDIF
  1217.  
  1218. ;
  1219. ; pascal OSErr GetPhysical(LogicalToPhysicalTable *addresses, unsigned long *physicalEntryCount)
  1220. ;
  1221.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1222.         Macro
  1223.         _GetPhysical
  1224.             moveq               #5,D0
  1225.             dc.w                $A05C
  1226.         EndM
  1227.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1228.         IMPORT_CFM_FUNCTION GetPhysical
  1229.     ENDIF
  1230.  
  1231. ;
  1232. ; pascal OSErr DeferUserFn(UserFnUPP userFunction, void *argument)
  1233. ;
  1234.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1235.         ; parameters:
  1236.         ;    userFunctionargument=> A0
  1237.         ;    argument        => D0
  1238.         ; returns:
  1239.         ;    OSErr           <= D0
  1240.         _DeferUserFn:    OPWORD    $A08F
  1241.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1242.         IMPORT_CFM_FUNCTION DeferUserFn
  1243.     ENDIF
  1244.  
  1245. ;
  1246. ; pascal long DebuggerGetMax(void )
  1247. ;
  1248.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1249.         ; returns:
  1250.         ;    long            <= D0
  1251.         Macro
  1252.         _DebuggerGetMax
  1253.             moveq               #0,D0
  1254.             dc.w                $A08D
  1255.         EndM
  1256.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1257.         IMPORT_CFM_FUNCTION DebuggerGetMax
  1258.     ENDIF
  1259.  
  1260. ;
  1261. ; pascal void DebuggerEnter(void )
  1262. ;
  1263.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1264.         Macro
  1265.         _DebuggerEnter
  1266.             moveq               #1,D0
  1267.             dc.w                $A08D
  1268.         EndM
  1269.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1270.         IMPORT_CFM_FUNCTION DebuggerEnter
  1271.     ENDIF
  1272.  
  1273. ;
  1274. ; pascal void DebuggerExit(void )
  1275. ;
  1276.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1277.         Macro
  1278.         _DebuggerExit
  1279.             moveq               #2,D0
  1280.             dc.w                $A08D
  1281.         EndM
  1282.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1283.         IMPORT_CFM_FUNCTION DebuggerExit
  1284.     ENDIF
  1285.  
  1286. ;
  1287. ; pascal void DebuggerPoll(void )
  1288. ;
  1289.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1290.         Macro
  1291.         _DebuggerPoll
  1292.             moveq               #3,D0
  1293.             dc.w                $A08D
  1294.         EndM
  1295.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1296.         IMPORT_CFM_FUNCTION DebuggerPoll
  1297.     ENDIF
  1298.  
  1299. ;
  1300. ; pascal PageState GetPageState(const void *address)
  1301. ;
  1302.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1303.         ; parameters:
  1304.         ;    address         => A0
  1305.         ; returns:
  1306.         ;    PageState       <= D0
  1307.         Macro
  1308.         _GetPageState
  1309.             moveq               #4,D0
  1310.             dc.w                $A08D
  1311.         EndM
  1312.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1313.         IMPORT_CFM_FUNCTION GetPageState
  1314.     ENDIF
  1315.  
  1316. ;
  1317. ; pascal Boolean PageFaultFatal(void )
  1318. ;
  1319.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1320.         ; returns:
  1321.         ;    Boolean         <= D0
  1322.         Macro
  1323.         _PageFaultFatal
  1324.             moveq               #5,D0
  1325.             dc.w                $A08D
  1326.         EndM
  1327.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1328.         IMPORT_CFM_FUNCTION PageFaultFatal
  1329.     ENDIF
  1330.  
  1331. ;
  1332. ; pascal OSErr DebuggerLockMemory(void *address, unsigned long count)
  1333. ;
  1334.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1335.         ; parameters:
  1336.         ;    address         => A0
  1337.         ;    count           => A1
  1338.         ; returns:
  1339.         ;    OSErr           <= D0
  1340.         Macro
  1341.         _DebuggerLockMemory
  1342.             moveq               #6,D0
  1343.             dc.w                $A08D
  1344.         EndM
  1345.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1346.         IMPORT_CFM_FUNCTION DebuggerLockMemory
  1347.     ENDIF
  1348.  
  1349. ;
  1350. ; pascal OSErr DebuggerUnlockMemory(void *address, unsigned long count)
  1351. ;
  1352.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1353.         ; parameters:
  1354.         ;    address         => A0
  1355.         ;    count           => A1
  1356.         ; returns:
  1357.         ;    OSErr           <= D0
  1358.         Macro
  1359.         _DebuggerUnlockMemory
  1360.             moveq               #7,D0
  1361.             dc.w                $A08D
  1362.         EndM
  1363.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1364.         IMPORT_CFM_FUNCTION DebuggerUnlockMemory
  1365.     ENDIF
  1366.  
  1367. ;
  1368. ; pascal StatusRegisterContents EnterSupervisorMode(void )
  1369. ;
  1370.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1371.         ; returns:
  1372.         ;    StatusRegisterContents <= D0
  1373.         Macro
  1374.         _EnterSupervisorMode
  1375.             moveq               #8,D0
  1376.             dc.w                $A08D
  1377.         EndM
  1378.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1379.         IMPORT_CFM_FUNCTION EnterSupervisorMode
  1380.     ENDIF
  1381.  
  1382.  
  1383. ;  
  1384. ;    StripAddress and Translate24To32 are traps on classic 68K,
  1385. ;    but macro to the identity function on PowerMacs or other OS's.
  1386. ;
  1387.  
  1388. ;
  1389. ; pascal Ptr StripAddress(void *theAddress)
  1390. ;
  1391.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1392.         ; parameters:
  1393.         ;    theAddress      => D0
  1394.         ; returns:
  1395.         ;    Ptr             <= D0
  1396.         _StripAddress:    OPWORD    $A055
  1397.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1398.         IMPORT_CFM_FUNCTION StripAddress
  1399.     ENDIF
  1400.  
  1401.  
  1402. ;
  1403. ; pascal Ptr Translate24To32(void *addr24)
  1404. ;
  1405.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1406.         ; parameters:
  1407.         ;    addr24          => D0
  1408.         ; returns:
  1409.         ;    Ptr             <= D0
  1410.         _Translate24To32:    OPWORD    $A091
  1411.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1412.         IMPORT_CFM_FUNCTION Translate24To32
  1413.     ENDIF
  1414.  
  1415. ;
  1416. ; pascal OSErr HandToHand(Handle *theHndl)
  1417. ;
  1418.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1419.         _HandToHand:    OPWORD    $A9E1
  1420.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1421.         IMPORT_CFM_FUNCTION HandToHand
  1422.     ENDIF
  1423.  
  1424. ;
  1425. ; pascal OSErr PtrToXHand(const void *srcPtr, Handle dstHndl, long size)
  1426. ;
  1427.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1428.         ; parameters:
  1429.         ;    srcPtr          => A0
  1430.         ;    dstHndl         => A1
  1431.         ;    size            => D0
  1432.         ; returns:
  1433.         ;    OSErr           <= D0
  1434.         _PtrToXHand:    OPWORD    $A9E2
  1435.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1436.         IMPORT_CFM_FUNCTION PtrToXHand
  1437.     ENDIF
  1438.  
  1439. ;
  1440. ; pascal OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size)
  1441. ;
  1442.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1443.         _PtrToHand:    OPWORD    $A9E3
  1444.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1445.         IMPORT_CFM_FUNCTION PtrToHand
  1446.     ENDIF
  1447.  
  1448. ;
  1449. ; pascal OSErr HandAndHand(Handle hand1, Handle hand2)
  1450. ;
  1451.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1452.         ; parameters:
  1453.         ;    hand1           => A0
  1454.         ;    hand2           => A1
  1455.         ; returns:
  1456.         ;    OSErr           <= D0
  1457.         _HandAndHand:    OPWORD    $A9E4
  1458.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1459.         IMPORT_CFM_FUNCTION HandAndHand
  1460.     ENDIF
  1461.  
  1462. ;
  1463. ; pascal OSErr PtrAndHand(const void *ptr1, Handle hand2, long size)
  1464. ;
  1465.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1466.         ; parameters:
  1467.         ;    ptr1            => A0
  1468.         ;    hand2           => A1
  1469.         ;    size            => D0
  1470.         ; returns:
  1471.         ;    OSErr           <= D0
  1472.         _PtrAndHand:    OPWORD    $A9EF
  1473.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1474.         IMPORT_CFM_FUNCTION PtrAndHand
  1475.     ENDIF
  1476.  
  1477.     IF OLDROUTINENAMES THEN
  1478.     ENDIF    ; OLDROUTINENAMES
  1479.     ENDIF ; __MACMEMORY__ 
  1480.  
  1481.